home *** CD-ROM | disk | FTP | other *** search
/ Gekikoh Dennoh Club 5 / Gekikoh Dennoh Club Vol. 5 (Japan).7z / Gekikoh Dennoh Club Vol. 5 (Japan) (Track 01).bin / internet / xip / iijppp.lzh / src / mbuf.c < prev    next >
C/C++ Source or Header  |  1994-09-25  |  3KB  |  185 lines
  1. /*
  2.  *          PPP Memory handling module
  3.  *
  4.  *        Written by Toshiharu OHNO (tony-o@iij.ad.jp)
  5.  *
  6.  *   Copyright (C) 1993, Internet Initiative Japan, Inc. All rights reserverd.
  7.  *
  8.  * Redistribution and use in source and binary forms are permitted
  9.  * provided that the above copyright notice and this paragraph are
  10.  * duplicated in all such forms and that any documentation,
  11.  * advertising materials, and other materials related to such
  12.  * distribution and use acknowledge that the software was developed
  13.  * by the Internet Initiative Japan, Inc.  The name of the
  14.  * IIJ may not be used to endorse or promote products derived
  15.  * from this software without specific prior written permission.
  16.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  17.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  18.  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  19.  *
  20.  */
  21. #include "defs.h"
  22.  
  23. struct memmap {
  24.   struct mbuf *queue;
  25.   int    count;
  26. } MemMap[MB_MAX+2];
  27.  
  28. static int totalalloced;
  29.  
  30. int
  31. plength(bp)
  32. struct mbuf *bp;
  33. {
  34.   int len;
  35.  
  36.   for (len = 0; bp; bp = bp->next)
  37.     len += bp->cnt;
  38.   return(len);
  39. }
  40.  
  41. struct mbuf *
  42. mballoc(cnt, type)
  43. int cnt;
  44. int type;
  45. {
  46.   u_char *p;
  47.   struct mbuf *bp;
  48.  
  49.   if (type > MB_MAX)
  50.     logprintf("bad type %d\n", type);
  51.   bp = (struct mbuf *)malloc(sizeof(struct mbuf));
  52.   bzero(bp, sizeof(struct mbuf));
  53.   p = (u_char *)malloc(cnt);
  54.   MemMap[type].count += cnt;
  55.   totalalloced += cnt;
  56.   bp->base = p;
  57.   bp->size = bp->cnt = cnt;
  58.   bp->type = type;
  59.   return(bp);
  60. }
  61.  
  62. struct mbuf *
  63. mbfree(struct mbuf *bp)
  64. {
  65.   struct mbuf *nbp;
  66.  
  67.   if (bp) {
  68.     nbp = bp->next;
  69.     MemMap[bp->type].count -= bp->size;
  70.     totalalloced -= bp->size;
  71.     free(bp->base);
  72.     free(bp);
  73.     return(nbp);
  74.   }
  75.   return(bp);
  76. }
  77.  
  78. void
  79. pfree(struct mbuf *bp)
  80. {
  81.   while (bp)
  82.     bp = mbfree(bp);
  83. }
  84.  
  85. struct mbuf *
  86. mbread(bp, ptr, len)
  87. struct mbuf *bp;
  88. u_char *ptr;
  89. int len;
  90. {
  91.   int nb;
  92.  
  93.   while (bp && len > 0) {
  94.     if (len > bp->cnt)
  95.       nb = bp->cnt;
  96.     else
  97.       nb = len;
  98.     bcopy(MBUF_CTOP(bp), ptr, nb);
  99.     ptr += nb;
  100.     bp->cnt -= nb;
  101.     len -= nb;
  102.     bp->offset += nb;
  103.     if (bp->cnt == 0) {
  104. #ifdef notdef
  105.       bp = bp->next;
  106. #else
  107.       bp = mbfree(bp);
  108. #endif
  109.     }
  110.   }
  111.   return(bp);
  112. }
  113.   
  114. void
  115. mbwrite(bp, ptr, cnt)
  116. struct mbuf *bp;
  117. u_char *ptr;
  118. int cnt;
  119. {
  120.   int plen;
  121.   int nb;
  122.  
  123.   plen = plength(bp);
  124.   if (plen < cnt)
  125.     cnt = plen;
  126.  
  127.   while (cnt > 0) {
  128.     nb = (cnt < bp->cnt)? cnt : bp->cnt;
  129.     bcopy(ptr, MBUF_CTOP(bp), nb);
  130.     cnt -= bp->cnt;
  131.     bp = bp->next;
  132.   }
  133. }
  134.  
  135. void
  136. DumpBp(bp)
  137. struct mbuf *bp;
  138. {
  139.   u_char *cp;
  140.   int cnt, loc;
  141.  
  142.   logprintf("dump bp = %x (%d)\n", bp, plength(bp));
  143.   loc = 0;
  144.   while (bp) {
  145.     cp = MBUF_CTOP(bp);
  146.     cnt = bp->cnt;
  147.     while (cnt > 0) {
  148.       logprintf("%02x", *cp++);
  149.       loc++;
  150.       if (loc == 16) {
  151.     loc = 0;
  152.     logprintf("\n");
  153.       } else
  154.     logprintf(" ");
  155.       cnt--;
  156.     }
  157.     bp = bp->next;
  158.   }
  159.   if (loc) logprintf("\n");
  160. }
  161.  
  162. int
  163. ShowMemMap()
  164. {
  165.   int i;
  166.  
  167.   for (i = 0; i <= MB_MAX; i += 2) {
  168.     printf("%d: %d   %d: %d\r\n",
  169.     i, MemMap[i].count, i+1, MemMap[i+1].count);
  170.   }
  171.   return(1);
  172. }
  173.  
  174. void
  175. LogMemory()
  176. {
  177. #ifdef DEBUG
  178.   logprintf("mem alloced: %d\n", totalalloced);
  179.   logprintf(" 1: %d  2: %d   3: %d   4: %d\n",
  180.     MemMap[1].count, MemMap[2].count, MemMap[3].count, MemMap[4].count);
  181.   logprintf(" 5: %d  6: %d   7: %d   8: %d\n",
  182.     MemMap[5].count, MemMap[6].count, MemMap[7].count, MemMap[8].count);
  183. #endif
  184. }
  185.